home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / amigaguide_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  12KB  |  406 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_AMIGAGUIDE_H
  4. #define _PPCPRAGMA_AMIGAGUIDE_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__AMIGAGUIDE_H
  7. #include <powerup/ppcinline/amigaguide.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef AMIGAGUIDE_BASE_NAME
  24. #define AMIGAGUIDE_BASE_NAME AmigaGuideBase
  25. #endif /* !AMIGAGUIDE_BASE_NAME */
  26.  
  27. #define    AddAmigaGuideHostA(h, name, attrs)    _AddAmigaGuideHostA(AMIGAGUIDE_BASE_NAME, h, name, attrs)
  28.  
  29. static __inline APTR
  30. _AddAmigaGuideHostA(void *AmigaGuideBase, struct Hook *h, STRPTR name, struct TagItem *attrs)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) h;
  40.     MyCaos.d0        =(ULONG) name;
  41.     MyCaos.a1        =(ULONG) attrs;
  42.     MyCaos.caos_Un.Offset    =    (-138);
  43.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  44.     return((APTR)PPCCallOS(&MyCaos));
  45. }
  46.  
  47. #ifndef NO_PPCINLINE_STDARG
  48. #define AddAmigaGuideHost(a0, a1, tags...) \
  49.     ({ULONG _tags[] = { tags }; AddAmigaGuideHostA((a0), (a1), (struct TagItem *)_tags);})
  50. #endif /* !NO_PPCINLINE_STDARG */
  51.  
  52. #define    AmigaGuideSignal(cl)    _AmigaGuideSignal(AMIGAGUIDE_BASE_NAME, cl)
  53.  
  54. static __inline ULONG
  55. _AmigaGuideSignal(void *AmigaGuideBase, APTR cl)
  56. {
  57. struct Caos    MyCaos;
  58.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  59. //    MyCaos.M68kStart    =    NULL;
  60. //    MyCaos.M68kSize        =    0;
  61.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  62. //    MyCaos.PPCStart        =    NULL;
  63. //    MyCaos.PPCSize        =    0;
  64.     MyCaos.a0        =(ULONG) cl;
  65.     MyCaos.caos_Un.Offset    =    (-72);
  66.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  67.     return((ULONG)PPCCallOS(&MyCaos));
  68. }
  69.  
  70. #define    CloseAmigaGuide(cl)    _CloseAmigaGuide(AMIGAGUIDE_BASE_NAME, cl)
  71.  
  72. static __inline void
  73. _CloseAmigaGuide(void *AmigaGuideBase, APTR cl)
  74. {
  75. struct Caos    MyCaos;
  76.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  77. //    MyCaos.M68kStart    =    NULL;
  78. //    MyCaos.M68kSize        =    0;
  79.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  80. //    MyCaos.PPCStart        =    NULL;
  81. //    MyCaos.PPCSize        =    0;
  82.     MyCaos.a0        =(ULONG) cl;
  83.     MyCaos.caos_Un.Offset    =    (-66);
  84.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  85.     PPCCallOS(&MyCaos);
  86. }
  87.  
  88. #define    ExpungeXRef()    _ExpungeXRef(AMIGAGUIDE_BASE_NAME)
  89.  
  90. static __inline void
  91. _ExpungeXRef(void *AmigaGuideBase)
  92. {
  93. struct Caos    MyCaos;
  94.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  95. //    MyCaos.M68kStart    =    NULL;
  96. //    MyCaos.M68kSize        =    0;
  97.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  98. //    MyCaos.PPCStart        =    NULL;
  99. //    MyCaos.PPCSize        =    0;
  100.     MyCaos.caos_Un.Offset    =    (-132);
  101.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  102.     PPCCallOS(&MyCaos);
  103. }
  104.  
  105. #define    GetAmigaGuideAttr(tag, cl, storage)    _GetAmigaGuideAttr(AMIGAGUIDE_BASE_NAME, tag, cl, storage)
  106.  
  107. static __inline LONG
  108. _GetAmigaGuideAttr(void *AmigaGuideBase, Tag tag, APTR cl, ULONG *storage)
  109. {
  110. struct Caos    MyCaos;
  111.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  112. //    MyCaos.M68kStart    =    NULL;
  113. //    MyCaos.M68kSize        =    0;
  114.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  115. //    MyCaos.PPCStart        =    NULL;
  116. //    MyCaos.PPCSize        =    0;
  117.     MyCaos.d0        =(ULONG) tag;
  118.     MyCaos.a0        =(ULONG) cl;
  119.     MyCaos.a1        =(ULONG) storage;
  120.     MyCaos.caos_Un.Offset    =    (-114);
  121.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  122.     return((LONG)PPCCallOS(&MyCaos));
  123. }
  124.  
  125. #define    GetAmigaGuideMsg(cl)    _GetAmigaGuideMsg(AMIGAGUIDE_BASE_NAME, cl)
  126.  
  127. static __inline struct AmigaGuideMsg *
  128. _GetAmigaGuideMsg(void *AmigaGuideBase, APTR cl)
  129. {
  130. struct Caos    MyCaos;
  131.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  132. //    MyCaos.M68kStart    =    NULL;
  133. //    MyCaos.M68kSize        =    0;
  134.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  135. //    MyCaos.PPCStart        =    NULL;
  136. //    MyCaos.PPCSize        =    0;
  137.     MyCaos.a0        =(ULONG) cl;
  138.     MyCaos.caos_Un.Offset    =    (-78);
  139.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  140.     return((struct AmigaGuideMsg *)PPCCallOS(&MyCaos));
  141. }
  142.  
  143. #define    GetAmigaGuideString(id)    _GetAmigaGuideString(AMIGAGUIDE_BASE_NAME, id)
  144.  
  145. static __inline STRPTR
  146. _GetAmigaGuideString(void *AmigaGuideBase, long id)
  147. {
  148. struct Caos    MyCaos;
  149.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  150. //    MyCaos.M68kStart    =    NULL;
  151. //    MyCaos.M68kSize        =    0;
  152.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  153. //    MyCaos.PPCStart        =    NULL;
  154. //    MyCaos.PPCSize        =    0;
  155.     MyCaos.d0        =(ULONG) id;
  156.     MyCaos.caos_Un.Offset    =    (-210);
  157.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  158.     return((STRPTR)PPCCallOS(&MyCaos));
  159. }
  160.  
  161. #define    LoadXRef(lock, name)    _LoadXRef(AMIGAGUIDE_BASE_NAME, lock, name)
  162.  
  163. static __inline LONG
  164. _LoadXRef(void *AmigaGuideBase, BPTR lock, STRPTR name)
  165. {
  166. struct Caos    MyCaos;
  167.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  168. //    MyCaos.M68kStart    =    NULL;
  169. //    MyCaos.M68kSize        =    0;
  170.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  171. //    MyCaos.PPCStart        =    NULL;
  172. //    MyCaos.PPCSize        =    0;
  173.     MyCaos.a0        =(ULONG) lock;
  174.     MyCaos.a1        =(ULONG) name;
  175.     MyCaos.caos_Un.Offset    =    (-126);
  176.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  177.     return((LONG)PPCCallOS(&MyCaos));
  178. }
  179.  
  180. #define    LockAmigaGuideBase(handle)    _LockAmigaGuideBase(AMIGAGUIDE_BASE_NAME, handle)
  181.  
  182. static __inline LONG
  183. _LockAmigaGuideBase(void *AmigaGuideBase, APTR handle)
  184. {
  185. struct Caos    MyCaos;
  186.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  187. //    MyCaos.M68kStart    =    NULL;
  188. //    MyCaos.M68kSize        =    0;
  189.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  190. //    MyCaos.PPCStart        =    NULL;
  191. //    MyCaos.PPCSize        =    0;
  192.     MyCaos.a0        =(ULONG) handle;
  193.     MyCaos.caos_Un.Offset    =    (-36);
  194.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  195.     return((LONG)PPCCallOS(&MyCaos));
  196. }
  197.  
  198. #define    OpenAmigaGuideA(nag, attrs)    _OpenAmigaGuideA(AMIGAGUIDE_BASE_NAME, nag, attrs)
  199.  
  200. static __inline APTR
  201. _OpenAmigaGuideA(void *AmigaGuideBase, struct NewAmigaGuide *nag, struct TagItem *attrs)
  202. {
  203. struct Caos    MyCaos;
  204.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  205. //    MyCaos.M68kStart    =    NULL;
  206. //    MyCaos.M68kSize        =    0;
  207.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  208. //    MyCaos.PPCStart        =    NULL;
  209. //    MyCaos.PPCSize        =    0;
  210.     MyCaos.a0        =(ULONG) nag;
  211.     MyCaos.a1        =(ULONG) attrs;
  212.     MyCaos.caos_Un.Offset    =    (-54);
  213.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  214.     return((APTR)PPCCallOS(&MyCaos));
  215. }
  216.  
  217. #ifndef NO_PPCINLINE_STDARG
  218. #define OpenAmigaGuide(a0, tags...) \
  219.     ({ULONG _tags[] = { tags }; OpenAmigaGuideA((a0), (struct TagItem *)_tags);})
  220. #endif /* !NO_PPCINLINE_STDARG */
  221.  
  222. #define    OpenAmigaGuideAsyncA(nag, attrs)    _OpenAmigaGuideAsyncA(AMIGAGUIDE_BASE_NAME, nag, attrs)
  223.  
  224. static __inline APTR
  225. _OpenAmigaGuideAsyncA(void *AmigaGuideBase, struct NewAmigaGuide *nag, struct TagItem *attrs)
  226. {
  227. struct Caos    MyCaos;
  228.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  229. //    MyCaos.M68kStart    =    NULL;
  230. //    MyCaos.M68kSize        =    0;
  231.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  232. //    MyCaos.PPCStart        =    NULL;
  233. //    MyCaos.PPCSize        =    0;
  234.     MyCaos.a0        =(ULONG) nag;
  235.     MyCaos.d0        =(ULONG) attrs;
  236.     MyCaos.caos_Un.Offset    =    (-60);
  237.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  238.     return((APTR)PPCCallOS(&MyCaos));
  239. }
  240.  
  241. #ifndef NO_PPCINLINE_STDARG
  242. #define OpenAmigaGuideAsync(a0, tags...) \
  243.     ({ULONG _tags[] = { tags }; OpenAmigaGuideAsyncA((a0), (struct TagItem *)_tags);})
  244. #endif /* !NO_PPCINLINE_STDARG */
  245.  
  246. #define    RemoveAmigaGuideHostA(hh, attrs)    _RemoveAmigaGuideHostA(AMIGAGUIDE_BASE_NAME, hh, attrs)
  247.  
  248. static __inline LONG
  249. _RemoveAmigaGuideHostA(void *AmigaGuideBase, APTR hh, struct TagItem *attrs)
  250. {
  251. struct Caos    MyCaos;
  252.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  253. //    MyCaos.M68kStart    =    NULL;
  254. //    MyCaos.M68kSize        =    0;
  255.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  256. //    MyCaos.PPCStart        =    NULL;
  257. //    MyCaos.PPCSize        =    0;
  258.     MyCaos.a0        =(ULONG) hh;
  259.     MyCaos.a1        =(ULONG) attrs;
  260.     MyCaos.caos_Un.Offset    =    (-144);
  261.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  262.     return((LONG)PPCCallOS(&MyCaos));
  263. }
  264.  
  265. #ifndef NO_PPCINLINE_STDARG
  266. #define RemoveAmigaGuideHost(a0, tags...) \
  267.     ({ULONG _tags[] = { tags }; RemoveAmigaGuideHostA((a0), (struct TagItem *)_tags);})
  268. #endif /* !NO_PPCINLINE_STDARG */
  269.  
  270. #define    ReplyAmigaGuideMsg(amsg)    _ReplyAmigaGuideMsg(AMIGAGUIDE_BASE_NAME, amsg)
  271.  
  272. static __inline void
  273. _ReplyAmigaGuideMsg(void *AmigaGuideBase, struct AmigaGuideMsg *amsg)
  274. {
  275. struct Caos    MyCaos;
  276.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  277. //    MyCaos.M68kStart    =    NULL;
  278. //    MyCaos.M68kSize        =    0;
  279.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  280. //    MyCaos.PPCStart        =    NULL;
  281. //    MyCaos.PPCSize        =    0;
  282.     MyCaos.a0        =(ULONG) amsg;
  283.     MyCaos.caos_Un.Offset    =    (-84);
  284.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  285.     PPCCallOS(&MyCaos);
  286. }
  287.  
  288. #define    SendAmigaGuideCmdA(cl, cmd, attrs)    _SendAmigaGuideCmdA(AMIGAGUIDE_BASE_NAME, cl, cmd, attrs)
  289.  
  290. static __inline LONG
  291. _SendAmigaGuideCmdA(void *AmigaGuideBase, APTR cl, STRPTR cmd, struct TagItem *attrs)
  292. {
  293. struct Caos    MyCaos;
  294.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  295. //    MyCaos.M68kStart    =    NULL;
  296. //    MyCaos.M68kSize        =    0;
  297.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  298. //    MyCaos.PPCStart        =    NULL;
  299. //    MyCaos.PPCSize        =    0;
  300.     MyCaos.a0        =(ULONG) cl;
  301.     MyCaos.d0        =(ULONG) cmd;
  302.     MyCaos.d1        =(ULONG) attrs;
  303.     MyCaos.caos_Un.Offset    =    (-102);
  304.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  305.     return((LONG)PPCCallOS(&MyCaos));
  306. }
  307.  
  308. #ifndef NO_PPCINLINE_STDARG
  309. #define SendAmigaGuideCmd(a0, a1, tags...) \
  310.     ({ULONG _tags[] = { tags }; SendAmigaGuideCmdA((a0), (a1), (struct TagItem *)_tags);})
  311. #endif /* !NO_PPCINLINE_STDARG */
  312.  
  313. #define    SendAmigaGuideContextA(cl, attrs)    _SendAmigaGuideContextA(AMIGAGUIDE_BASE_NAME, cl, attrs)
  314.  
  315. static __inline LONG
  316. _SendAmigaGuideContextA(void *AmigaGuideBase, APTR cl, struct TagItem *attrs)
  317. {
  318. struct Caos    MyCaos;
  319.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  320. //    MyCaos.M68kStart    =    NULL;
  321. //    MyCaos.M68kSize        =    0;
  322.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  323. //    MyCaos.PPCStart        =    NULL;
  324. //    MyCaos.PPCSize        =    0;
  325.     MyCaos.a0        =(ULONG) cl;
  326.     MyCaos.d0        =(ULONG) attrs;
  327.     MyCaos.caos_Un.Offset    =    (-96);
  328.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  329.     return((LONG)PPCCallOS(&MyCaos));
  330. }
  331.  
  332. #ifndef NO_PPCINLINE_STDARG
  333. #define SendAmigaGuideContext(a0, tags...) \
  334.     ({ULONG _tags[] = { tags }; SendAmigaGuideContextA((a0), (struct TagItem *)_tags);})
  335. #endif /* !NO_PPCINLINE_STDARG */
  336.  
  337. #define    SetAmigaGuideAttrsA(cl, attrs)    _SetAmigaGuideAttrsA(AMIGAGUIDE_BASE_NAME, cl, attrs)
  338.  
  339. static __inline LONG
  340. _SetAmigaGuideAttrsA(void *AmigaGuideBase, APTR cl, struct TagItem *attrs)
  341. {
  342. struct Caos    MyCaos;
  343.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  344. //    MyCaos.M68kStart    =    NULL;
  345. //    MyCaos.M68kSize        =    0;
  346.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  347. //    MyCaos.PPCStart        =    NULL;
  348. //    MyCaos.PPCSize        =    0;
  349.     MyCaos.a0        =(ULONG) cl;
  350.     MyCaos.a1        =(ULONG) attrs;
  351.     MyCaos.caos_Un.Offset    =    (-108);
  352.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  353.     return((LONG)PPCCallOS(&MyCaos));
  354. }
  355.  
  356. #ifndef NO_PPCINLINE_STDARG
  357. #define SetAmigaGuideAttrs(a0, tags...) \
  358.     ({ULONG _tags[] = { tags }; SetAmigaGuideAttrsA((a0), (struct TagItem *)_tags);})
  359. #endif /* !NO_PPCINLINE_STDARG */
  360.  
  361. #define    SetAmigaGuideContextA(cl, id, attrs)    _SetAmigaGuideContextA(AMIGAGUIDE_BASE_NAME, cl, id, attrs)
  362.  
  363. static __inline LONG
  364. _SetAmigaGuideContextA(void *AmigaGuideBase, APTR cl, unsigned long id, struct TagItem *attrs)
  365. {
  366. struct Caos    MyCaos;
  367.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  368. //    MyCaos.M68kStart    =    NULL;
  369. //    MyCaos.M68kSize        =    0;
  370.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  371. //    MyCaos.PPCStart        =    NULL;
  372. //    MyCaos.PPCSize        =    0;
  373.     MyCaos.a0        =(ULONG) cl;
  374.     MyCaos.d0        =(ULONG) id;
  375.     MyCaos.d1        =(ULONG) attrs;
  376.     MyCaos.caos_Un.Offset    =    (-90);
  377.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  378.     return((LONG)PPCCallOS(&MyCaos));
  379. }
  380.  
  381. #ifndef NO_PPCINLINE_STDARG
  382. #define SetAmigaGuideContext(a0, a1, tags...) \
  383.     ({ULONG _tags[] = { tags }; SetAmigaGuideContextA((a0), (a1), (struct TagItem *)_tags);})
  384. #endif /* !NO_PPCINLINE_STDARG */
  385.  
  386. #define    UnlockAmigaGuideBase(key)    _UnlockAmigaGuideBase(AMIGAGUIDE_BASE_NAME, key)
  387.  
  388. static __inline void
  389. _UnlockAmigaGuideBase(void *AmigaGuideBase, long key)
  390. {
  391. struct Caos    MyCaos;
  392.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  393. //    MyCaos.M68kStart    =    NULL;
  394. //    MyCaos.M68kSize        =    0;
  395.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  396. //    MyCaos.PPCStart        =    NULL;
  397. //    MyCaos.PPCSize        =    0;
  398.     MyCaos.d0        =(ULONG) key;
  399.     MyCaos.caos_Un.Offset    =    (-42);
  400.     MyCaos.a6        =(ULONG) AmigaGuideBase;    
  401.     PPCCallOS(&MyCaos);
  402. }
  403.  
  404. #endif /* SASC Pragmas */
  405. #endif /* !_PPCPRAGMA_AMIGAGUIDE_H */
  406.